const { spawn } = require('child_process');
const path = require('path');
const fs = require('fs');
const os = require('os');
const { app } = require('electron');

/**
 * 自动启动脚本管理器
 * 在 whistle 客户端启动后自动执行指定的命令
 */
class AutoStartupManager {
  constructor() {
    this.processes = new Map();
    this.configPath = path.join(__dirname, '../config/startup-commands.json');
    this.config = this.loadConfig();
  }

  /**
   * 加载配置文件
   */
  loadConfig() {
    try {
      if (fs.existsSync(this.configPath)) {
        const configContent = fs.readFileSync(this.configPath, 'utf8');
        const config = JSON.parse(configContent);
        console.log('[AutoStartup] 配置文件加载成功');
        return config;
      } else {
        console.log('[AutoStartup] 配置文件不存在，使用默认配置');
        return this.getDefaultConfig();
      }
    } catch (error) {
      console.error('[AutoStartup] 配置文件加载失败，使用默认配置:', error.message);
      return this.getDefaultConfig();
    }
  }

  /**
   * 获取默认配置
   */
  getDefaultConfig() {
    return {
      version: "1.0.0",
      description: "Whistle 客户端自动启动命令配置",
      commands: [
        {
          name: 'lack-watch',
          description: 'Lack Watch 命令 - 监控文件变化',
          command: 'lack',
          args: ['watch'],
          cwd: null,
          enabled: true,
          autoStart: true,
          runInTerminal: false,
          platform: ['win32', 'darwin', 'linux']
        }
      ],
      settings: {
        executeDelay: 2000,
        maxRetries: 3,
        logOutput: true
      }
    };
  }

  /**
   * 保存配置文件
   */
  saveConfig() {
    try {
      const configDir = path.dirname(this.configPath);
      if (!fs.existsSync(configDir)) {
        fs.mkdirSync(configDir, { recursive: true });
      }
      fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
      console.log('[AutoStartup] 配置文件保存成功');
    } catch (error) {
      console.error('[AutoStartup] 配置文件保存失败:', error.message);
    }
  }

  /**
   * 执行自动启动命令
   */
  async executeStartupCommands() {
    console.log('');
    console.log('='.repeat(60));
    console.log('[AutoStartup] 🚀 开始执行自动启动命令...');
    console.log('[AutoStartup] 🎯 如果看到任何弹窗，请立即告知具体内容！');
    console.log('='.repeat(60));
    
    const currentPlatform = process.platform;
    const settings = this.config.settings || {};
    const executeDelay = settings.executeDelay || 2000;
    
    console.log(`[AutoStartup] 📋 当前平台: ${currentPlatform}`);
    console.log(`[AutoStartup] ⚙️  配置文件: ${this.configPath}`);
    console.log(`[AutoStartup] ⏱️  执行延迟: ${executeDelay}ms`);
    
    // 延迟执行，确保 whistle 完全启动
    if (executeDelay > 0) {
      console.log(`[AutoStartup] ⏳ 等待 ${executeDelay}ms 确保 Whistle 完全启动...`);
      for (let i = executeDelay / 1000; i > 0; i--) {
        process.stdout.write(`\r[AutoStartup] ⏳ 倒计时: ${i}s `);
        await new Promise(resolve => setTimeout(resolve, 1000));
      }
      console.log('\r[AutoStartup] ✅ 等待完成，开始执行命令');
    }
    
    const enabledCommands = this.config.commands.filter(cmd => {
      // 检查是否启用
      if (!cmd.enabled || !cmd.autoStart) {
        console.log(`[AutoStartup] ⏭️  跳过已禁用的命令: ${cmd.name} (enabled: ${cmd.enabled}, autoStart: ${cmd.autoStart})`);
        return false;
      }
      
      // 检查平台兼容性
      if (cmd.platform && !cmd.platform.includes(currentPlatform)) {
        console.log(`[AutoStartup] ⏭️  跳过不兼容平台的命令: ${cmd.name} (当前平台: ${currentPlatform}, 支持平台: ${cmd.platform.join(', ')})`);
        return false;
      }
      
      return true;
    });
    
    console.log('');
    console.log(`[AutoStartup] 📝 总命令数: ${this.config.commands.length}`);
    console.log(`[AutoStartup] ✅ 可执行命令数: ${enabledCommands.length}`);
    
    if (enabledCommands.length === 0) {
      console.log(`[AutoStartup] ❌ 没有可执行的命令`);
      return;
    }
    
    console.log('');
    console.log('-'.repeat(40));
    
    for (let i = 0; i < enabledCommands.length; i++) {
      const cmdConfig = enabledCommands[i];
      
      console.log(`[AutoStartup] 📦 执行命令 ${i + 1}/${enabledCommands.length}: ${cmdConfig.name}`);
      
      try {
        await this.executeCommand(cmdConfig);
        console.log(`[AutoStartup] ✅ 命令 ${cmdConfig.name} 启动成功`);
        
        // 命令间添加小间隔
        if (i < enabledCommands.length - 1) {
          console.log(`[AutoStartup] ⏳ 等待 500ms 后执行下一个命令...`);
          await new Promise(resolve => setTimeout(resolve, 500));
        }
      } catch (error) {
        console.error(`[AutoStartup] ❌ 执行命令 ${cmdConfig.name} 失败:`, error.message);
        console.error(`[AutoStartup] 🔍 错误详情:`, error);
        
        // 如果配置了重试，可以在这里添加重试逻辑
        const maxRetries = settings.maxRetries || 0;
        if (maxRetries > 0) {
          console.log(`[AutoStartup] 🔄 将在后续版本中实现重试功能 (最大重试次数: ${maxRetries})`);
        }
      }
    }
    
    console.log('');
    console.log('='.repeat(60));
    console.log('[AutoStartup] 🎉 自动启动命令执行完成！');
    console.log('='.repeat(60));
    console.log('');
  }

  /**
   * 执行单个命令
   * @param {Object} cmdConfig 命令配置
   */
  async executeCommand(cmdConfig) {
    const { name, command, args = [], cwd, description, runInTerminal = false } = cmdConfig;
    
    console.log('');
    console.log(`   🏷️  命令名称: ${name}`);
    console.log(`   📝 命令描述: ${description || '无描述'}`);
    console.log(`   💻 执行命令: ${command} ${args.join(' ')}`);
    console.log(`   📁 工作目录: ${cwd || '当前目录'}`);
    console.log(`   🎯 执行模式: ${runInTerminal ? '🖥️ 终端窗口' : '🤫 后台静默'}`);
    console.log(`   ⚙️  日志输出: ${this.config.settings?.logOutput ? '✅ 启用' : '❌ 禁用'}`);

    try {
      let process;

      console.log(`   🚀 启动进程...`);

      if (runInTerminal) {
        // 在新终端窗口中执行
        console.log(`   🖥️  在新终端窗口中启动...`);
        process = await this.executeInTerminal(cmdConfig);
      } else {
        // 在后台静默执行
        console.log(`   🤫 在后台静默启动...`);
        process = await this.executeInBackground(cmdConfig);
      }

      if (process) {
        // 分离进程，避免影响主应用
        process.unref();
        
        // 存储进程引用
        this.processes.set(name, process);
        
        const mode = runInTerminal ? '🖥️ 新终端窗口' : '🤫 后台静默';
        console.log(`   ✅ 进程已启动！PID: ${process.pid || '未知'}`);
        console.log(`   📍 执行位置: ${mode}`);
        
        // 监听进程事件
        process.on('error', (error) => {
          console.error(`   ❌ [${name}] 进程出错:`, error.message);
          console.error(`   🔍 错误类型:`, error.code || '未知');
        });

        process.on('exit', (code, signal) => {
          if (code === 0) {
            console.log(`   ✅ [${name}] 进程正常退出，退出码: ${code}`);
          } else {
            console.log(`   ⚠️  [${name}] 进程异常退出，退出码: ${code}，信号: ${signal || '无'}`);
          }
          this.processes.delete(name);
        });

        process.on('spawn', () => {
          console.log(`   🎉 [${name}] 进程成功启动！`);
        });

        // 如果是静默执行，监听输出（可选）
        if (!runInTerminal && this.config.settings && this.config.settings.logOutput) {
          console.log(`   👂 开始监听命令输出...`);
          
          if (process.stdout) {
            process.stdout.on('data', (data) => {
              const output = data.toString().trim();
              if (output) {
                console.log(`   📤 [${name}] 输出: ${output}`);
              }
            });
          }
          
          if (process.stderr) {
            process.stderr.on('data', (data) => {
              const error = data.toString().trim();
              if (error) {
                console.error(`   📤 [${name}] 错误: ${error}`);
              }
            });
          }
        } else if (!runInTerminal) {
          console.log(`   🔇 静默模式，不显示输出 (logOutput: ${this.config.settings?.logOutput})`);
        }

        // 等待一小段时间确保进程启动
        await new Promise(resolve => setTimeout(resolve, 100));
        
        if (process.pid) {
          console.log(`   🎯 进程状态: 运行中 (PID: ${process.pid})`);
        }

      } else {
        throw new Error('进程创建失败，返回了空值');
      }

    } catch (error) {
      console.error(`   ❌ 启动命令 ${name} 失败!`);
      console.error(`   🔍 错误信息: ${error.message}`);
      console.error(`   📋 错误代码: ${error.code || '未知'}`);
      console.error(`   🆘 建议检查: 命令是否存在、路径是否正确、权限是否足够`);
      throw error;
    }
  }

  /**
   * 在后台静默执行命令
   * @param {Object} cmdConfig 命令配置
   */
  async executeInBackground(cmdConfig) {
    const { command, args = [], cwd, env = {}, forceSpawn = false } = cmdConfig;
    let workingDir = cwd || process.cwd();
    
    // 处理特殊路径 - 改进版本，支持 asar 和相对路径格式
    if (cwd && (cwd === './node_modules/whistle.nohost' || cwd.includes('whistle.nohost'))) {
      // 检测是否在 asar 环境中
      const isAsar = __dirname.includes('app.asar');
      if (isAsar) {
        // 在 asar 模式下，使用 app.asar.unpacked 路径
        const appPath = process.resourcesPath;
        workingDir = path.join(appPath, 'app.asar.unpacked/node_modules/whistle.nohost');
        console.log(`     🔄 [ASAR模式] 使用 unpacked 路径: ${workingDir}`);
      } else {
        // 开发模式或非 asar 模式
        workingDir = path.join(__dirname, '../node_modules/whistle.nohost');
        console.log(`     🔄 [开发模式] 使用开发路径: ${workingDir}`);
      }
    } else if (cwd && cwd.startsWith('./')) {
      // 处理其他相对路径
      workingDir = path.resolve(cwd);
      console.log(`     🔄 解析相对路径为绝对路径: ${workingDir}`);
    }
    
    const logOutput = this.config.settings && this.config.settings.logOutput;
    
    console.log(`     📂 工作目录: ${workingDir}`);
    console.log(`     📂 目录是否存在: ${fs.existsSync(workingDir) ? '✅ 是' : '❌ 否'}`);
    console.log(`     🔧 spawn 参数: command="${command}", args=[${args.map(a => `"${a}"`).join(', ')}]`);
    console.log(`     🎛️  stdio 模式: ${logOutput ? 'pipe (捕获输出)' : 'ignore (忽略输出)'}`);
    
    try {
      // 创建子进程，设置最小化窗口
      let childProcess;
      const isWindows = process.platform === 'win32';
      
      if (isWindows) {
        // 如果强制spawn或者其他条件，直接使用spawn
        if (forceSpawn) {
          console.log(`     🚀 强制使用spawn方案执行: ${command} ${args.join(' ')}`);
          console.log(`     📂 工作目录: ${workingDir}`);
          
          // 直接使用spawn启动
          childProcess = spawn(command, args, {
            cwd: workingDir,
            detached: false,
            stdio: logOutput ? 'pipe' : 'ignore',
            shell: false,
            windowsHide: true,
            env: { ...process.env, ...env }
          });
          
          console.log(`     ✅ spawn启动成功: PID ${childProcess.pid}`);
          
        } else {
          // Windows下使用更简单可靠的方案
          try {
            // 方案1: 直接在当前进程中执行 lack watch（最隐蔽的方案）
            console.log(`     🚀 使用进程内隐藏方案执行: ${command} ${args.join(' ')}`);
            console.log(`     📂 工作目录: ${workingDir}`);
            
            // 特殊处理 lack watch 命令 - 完全静默的内嵌执行
            if (args.includes('node_modules/lack/bin/index.js') && args.includes('watch')) {
            console.log(`     🎯 检测到 lack watch 命令，使用完全静默内嵌执行`);
            
            // 保存当前工作目录和环境变量
            const originalCwd = process.cwd();
            const originalEnv = { ...process.env };
            
            try {
              // 设置环境变量
              Object.entries(env).forEach(([key, value]) => {
                process.env[key] = value;
              });
              
              // 切换到目标工作目录
              process.chdir(workingDir);
              
              // 直接加载并执行 lack watch 模块
              const lackWatchPath = path.join(workingDir, 'node_modules/lack/bin/watch.js');
              console.log(`     📝 直接内嵌执行 lack watch: ${lackWatchPath}`);
              console.log(`     🔍 检查路径是否存在: ${fs.existsSync(lackWatchPath) ? '✅ 存在' : '❌ 不存在'}`);
              
              if (fs.existsSync(lackWatchPath)) {
                // 完全静默执行 - 重定向所有输出
                const originalConsole = {
                  log: console.log,
                  error: console.error,
                  warn: console.warn,
                  info: console.info
                };
                
                // 临时禁用所有控制台输出
                console.log = () => {};
                console.error = () => {};
                console.warn = () => {};
                console.info = () => {};
                
                // 使用 setTimeout 异步执行，避免阻塞主进程
                setTimeout(() => {
                  try {
                    // 直接 require 并执行 lack watch
                    const lackWatch = require(lackWatchPath);
                    if (typeof lackWatch === 'function') {
                      lackWatch();
                    }
                    
                    // 恢复控制台输出
                    Object.assign(console, originalConsole);
                    console.log(`     ✅ lack watch 已静默启动并运行`);
                    
                  } catch (lackError) {
                    // 恢复控制台输出
                    Object.assign(console, originalConsole);
                    console.error(`     ❌ lack watch 内嵌执行失败: ${lackError.message}`);
                  }
                  
                  // 恢复原始工作目录
                  process.chdir(originalCwd);
                }, 100);
                
                // 创建一个虚拟的 childProcess 对象
                childProcess = {
                  pid: process.pid,
                  kill: () => {
                    console.log(`     🛑 停止 lack watch（内嵌模式）`);
                  },
                  on: () => {},
                  unref: () => {}
                };
                
                console.log(`     ✅ lack watch 内嵌执行启动成功（完全静默）`);
                
              } else {
                console.error(`     ❌ lack watch 模块不存在: ${lackWatchPath}`);
                throw new Error(`lack watch 模块不存在: ${lackWatchPath}`);
              }
              
            } catch (inlineError) {
              // 恢复原始状态
              process.chdir(originalCwd);
              Object.assign(process.env, originalEnv);
              console.error(`     ❌ 内嵌执行失败: ${inlineError.message}`);
              throw inlineError;
            }
            
          } else {
            // 非 lack watch 命令，使用原有的隐藏启动方式
            console.log(`     ⚠️  非 lack watch 命令，跳转到备选方案`);
            throw new Error('非 lack watch 命令，使用备选方案');
          }
          
        } catch (directError) {
          console.log(`     🚨 内嵌方案失败，原因: ${directError.message}`);
          console.log(`     🔄 尝试增强版内嵌方案...`);
          
          try {
            // 增强版内嵌方案：使用纯JavaScript实现文件监控
            console.log(`     📦 启动纯JavaScript文件监控（自定义实现）`);
            
            // 直接使用 chokidar 实现文件监控，避免调用 lack 的复杂逻辑
            const chokidar = require('chokidar');
            const originalCwd = process.cwd();
            
            // 设置环境变量
            Object.entries(env).forEach(([key, value]) => {
              process.env[key] = value;
            });
            
            // 切换到目标目录
            process.chdir(workingDir);
            
            // 定义监控的文件和目录
            const watchList = ['index.js', 'rules.txt', '_rules.txt', '_values.txt',
              'resRules.txt', 'lib', 'dist', 'public', 'initial.js'];
            
            console.log(`     👀 监控文件列表: ${watchList.join(', ')}`);
            
            // 创建文件监控器
            const watcher = chokidar.watch(watchList, {
              ignored: /(^|[\/\\])\../,  // 忽略隐藏文件
              persistent: true,
              ignoreInitial: true
            });
            
            // 文件变化处理（静默模式）
            let changeTimer;
            watcher.on('all', (event, path) => {
              if (process.env.SILENT !== '1') {
                console.log(`     📝 文件变化: ${event} ${path}`);
              }
              
              // 防抖处理：1秒内的多次变化只触发一次
              clearTimeout(changeTimer);
              changeTimer = setTimeout(() => {
                try {
                  // 触摸 package.json 文件，通知 whistle 重载
                  const now = new Date();
                  const fs = require('fs');
                  const packagePath = path.join(process.cwd(), 'package.json');
                  if (fs.existsSync(packagePath)) {
                    fs.utimesSync(packagePath, now, now);
                    if (process.env.SILENT !== '1') {
                      console.log(`     🔄 触发插件重载`);
                    }
                  }
                } catch (touchError) {
                  console.error(`     ❌ 触发重载失败: ${touchError.message}`);
                }
              }, 1000);
            });
            
            // 错误处理
            watcher.on('error', error => {
              console.error(`     ❌ 文件监控错误: ${error.message}`);
            });
            
            // 恢复原始工作目录
            process.chdir(originalCwd);
            
            console.log(`     ✅ 纯JavaScript文件监控启动成功（完全静默）`);
            
            // 创建 childProcess 对象
            childProcess = {
              pid: process.pid,
              kill: () => {
                console.log(`     🛑 停止文件监控`);
                watcher.close();
              },
              on: () => {},
              unref: () => {}
            };
            
          } catch (enhancedError) {
            console.log(`     ❌ 增强版内嵌方案也失败: ${enhancedError.message}`);
            console.log(`     ⚠️  作为最后手段，功能将被禁用以避免弹窗`);
            
            // 最后的虚拟进程
            childProcess = {
              pid: -1,
              kill: () => {
                console.log(`     ℹ️  lack watch 功能已禁用`);
              },
              on: () => {},
              unref: () => {}
            };
          }
        }
        }
      } else {
        // 非Windows系统使用原方案
        childProcess = spawn(command, args, {
          cwd: workingDir,
          detached: true,
          stdio: 'ignore',
          shell: true,
          windowsHide: true,
          env: { ...process.env, ...env }
        });
      }
      
      console.log(`     ✅ spawn 调用成功`);
      return childProcess;
      
    } catch (error) {
      console.error(`     ❌ spawn 调用失败:`, error.message);
      throw error;
    }
  }

  /**
   * 在新终端窗口中执行命令
   * @param {Object} cmdConfig 命令配置
   */
  async executeInTerminal(cmdConfig) {
    const { command, args = [], cwd, env = {} } = cmdConfig;
    const platform = process.platform;
    const workingDir = cwd || process.cwd();
    
    console.log(`     🖥️  当前平台: ${platform}`);
    console.log(`     📂 工作目录: ${workingDir}`);
    
    if (platform === 'win32') {
      // Windows: 使用 cmd 启动新的命令提示符窗口
      const fullCommand = `${command} ${args.join(' ')}`;
      console.log(`     🪟 Windows 终端启动...`);
      console.log(`     💻 完整命令: ${fullCommand}`);
      console.log(`     🔧 启动器: cmd /c start cmd /k`);
      
      return spawn('cmd', ['/c', 'start', 'cmd', '/k', fullCommand], {
        cwd: workingDir,
        detached: true,
        stdio: 'ignore',
        env: { ...process.env, ...env }
      });
    } else if (platform === 'darwin') {
      // macOS: 使用 osascript 启动 Terminal.app
      const fullCommand = `${command} ${args.join(' ')}`;
      const script = `tell application "Terminal" to do script "${fullCommand}"`;
      console.log(`     🍎 macOS 终端启动...`);
      console.log(`     💻 完整命令: ${fullCommand}`);
      console.log(`     🔧 启动器: osascript -e`);
      console.log(`     📜 AppleScript: ${script}`);
      
      return spawn('osascript', ['-e', script], {
        detached: true,
        stdio: 'ignore',
        env: { ...process.env, ...env }
      });
    } else {
      // Linux: 尝试使用常见的终端模拟器
      const terminals = ['gnome-terminal', 'konsole', 'xterm'];
      console.log(`     🐧 Linux 终端启动...`);
      console.log(`     🔍 尝试终端: ${terminals.join(', ')}`);
      
      for (let i = 0; i < terminals.length; i++) {
        const terminal = terminals[i];
        try {
          const fullCommand = `${command} ${args.join(' ')}`;
          console.log(`     📱 尝试终端 ${i + 1}/${terminals.length}: ${terminal}`);
          console.log(`     💻 完整命令: ${fullCommand}`);
          
          if (terminal === 'gnome-terminal') {
            console.log(`     🔧 启动参数: ${terminal} -- bash -c "${fullCommand}; exec bash"`);
            return spawn(terminal, ['--', 'bash', '-c', `${fullCommand}; exec bash`], {
              cwd: workingDir,
              detached: true,
              stdio: 'ignore',
              env: { ...process.env, ...env }
            });
          } else if (terminal === 'konsole') {
            console.log(`     🔧 启动参数: ${terminal} -e bash -c "${fullCommand}; exec bash"`);
            return spawn(terminal, ['-e', 'bash', '-c', `${fullCommand}; exec bash`], {
              cwd: workingDir,
              detached: true,
              stdio: 'ignore',
              env: { ...process.env, ...env }
            });
          } else {
            console.log(`     🔧 启动参数: ${terminal} -e bash -c "${fullCommand}; exec bash"`);
            return spawn(terminal, ['-e', 'bash', '-c', `${fullCommand}; exec bash`], {
              cwd: workingDir,
              detached: true,
              stdio: 'ignore',
              env: { ...process.env, ...env }
            });
          }
        } catch (err) {
          console.log(`     ❌ 终端 ${terminal} 启动失败: ${err.message}`);
          continue;
        }
      }
      
      throw new Error(`未找到可用的终端模拟器。尝试过: ${terminals.join(', ')}`);
    }
  }

  /**
   * 清理所有启动的进程
   */
  cleanup() {
    console.log('');
    console.log('🧹'.repeat(30));
    console.log('[AutoStartup] 🧹 开始清理自动启动的进程...');
    console.log('🧹'.repeat(30));
    
    if (this.processes.size === 0) {
      console.log('[AutoStartup] 📭 没有需要清理的进程');
      return;
    }
    
    console.log(`[AutoStartup] 📝 需要清理的进程数量: ${this.processes.size}`);
    
    for (const [name, process] of this.processes) {
      try {
        console.log(`[AutoStartup] 🔍 检查进程: ${name} (PID: ${process.pid || '未知'})`);
        
        if (process && !process.killed) {
          console.log(`[AutoStartup] 🛑 终止进程: ${name}`);
          process.kill();
          console.log(`[AutoStartup] ✅ 进程 ${name} 已发送终止信号`);
        } else {
          console.log(`[AutoStartup] ⏭️  进程 ${name} 已经停止或不存在`);
        }
      } catch (error) {
        console.error(`[AutoStartup] ❌ 终止进程 ${name} 失败:`, error.message);
        console.error(`[AutoStartup] 🔍 错误代码:`, error.code || '未知');
      }
    }
    
    this.processes.clear();
    console.log('');
    console.log('[AutoStartup] 🎉 进程清理完成！');
    console.log('🧹'.repeat(30));
    console.log('');
  }

  /**
   * 添加新的启动命令
   * @param {Object} cmdConfig 命令配置
   */
  addCommand(cmdConfig) {
    this.config.commands.push(cmdConfig);
    this.saveConfig();
    console.log(`[AutoStartup] 已添加新命令: ${cmdConfig.name}`);
  }

  /**
   * 启用/禁用命令
   * @param {string} name 命令名称
   * @param {boolean} enabled 是否启用
   */
  setCommandEnabled(name, enabled) {
    const cmd = this.config.commands.find(c => c.name === name);
    if (cmd) {
      cmd.enabled = enabled;
      this.saveConfig();
      console.log(`[AutoStartup] 命令 ${name} 已${enabled ? '启用' : '禁用'}`);
    }
  }

  /**
   * 设置命令自动启动
   * @param {string} name 命令名称
   * @param {boolean} autoStart 是否自动启动
   */
  setCommandAutoStart(name, autoStart) {
    const cmd = this.config.commands.find(c => c.name === name);
    if (cmd) {
      cmd.autoStart = autoStart;
      this.saveConfig();
      console.log(`[AutoStartup] 命令 ${name} 自动启动已${autoStart ? '启用' : '禁用'}`);
    }
  }

  /**
   * 删除命令
   * @param {string} name 命令名称
   */
  removeCommand(name) {
    const index = this.config.commands.findIndex(c => c.name === name);
    if (index !== -1) {
      this.config.commands.splice(index, 1);
      this.saveConfig();
      console.log(`[AutoStartup] 已删除命令: ${name}`);
      
      // 如果进程还在运行，终止它
      const process = this.processes.get(name);
      if (process && !process.killed) {
        process.kill();
        this.processes.delete(name);
      }
    }
  }

  /**
   * 获取所有命令配置
   */
  getCommands() {
    return this.config.commands;
  }

  /**
   * 获取配置
   */
  getConfig() {
    return this.config;
  }

  /**
   * 更新设置
   * @param {Object} settings 新的设置
   */
  updateSettings(settings) {
    this.config.settings = { ...this.config.settings, ...settings };
    this.saveConfig();
    console.log('[AutoStartup] 设置已更新');
  }

  /**
   * 重新加载配置
   */
  reloadConfig() {
    this.config = this.loadConfig();
    console.log('[AutoStartup] 配置已重新加载');
  }
}

// 创建单例实例
const autoStartupManager = new AutoStartupManager();

// 监听应用退出事件，清理进程
app.on('before-quit', () => {
  autoStartupManager.cleanup();
});

module.exports = autoStartupManager;
